home *** CD-ROM | disk | FTP | other *** search
/ Magnum One / Magnum One (Mid-American Digital) (Disc Manufacturing).iso / d12 / snip9_91.arc / DESCRYPT.C < prev    next >
C/C++ Source or Header  |  1991-09-17  |  9KB  |  382 lines
  1. /* @(#)crypt.c   4.1 (Berkeley) 12/21/80 */
  2. /*
  3.  * This program implements the
  4.  * Proposed Federal Information Processing
  5.  *  Data Encryption Standard.
  6.  * See Federal Register, March 17, 1975 (40FR12134)
  7.  */
  8.  
  9. /*
  10.  * Initial permutation,
  11.  */
  12. static   char   IP[] = {
  13.    58,50,42,34,26,18,10, 2,
  14.    60,52,44,36,28,20,12, 4,
  15.    62,54,46,38,30,22,14, 6,
  16.    64,56,48,40,32,24,16, 8,
  17.    57,49,41,33,25,17, 9, 1,
  18.    59,51,43,35,27,19,11, 3,
  19.    61,53,45,37,29,21,13, 5,
  20.    63,55,47,39,31,23,15, 7,
  21. };
  22.  
  23. /*
  24.  * Final permutation, FP = IP^(-1)
  25.  */
  26. static   char   FP[] = {
  27.    40, 8,48,16,56,24,64,32,
  28.    39, 7,47,15,55,23,63,31,
  29.    38, 6,46,14,54,22,62,30,
  30.    37, 5,45,13,53,21,61,29,
  31.    36, 4,44,12,52,20,60,28,
  32.    35, 3,43,11,51,19,59,27,
  33.    34, 2,42,10,50,18,58,26,
  34.    33, 1,41, 9,49,17,57,25,
  35. };
  36.  
  37. /*
  38.  * Permuted-choice 1 from the key bits
  39.  * to yield C and D.
  40.  * Note that bits 8,16... are left out:
  41.  * They are intended for a parity check.
  42.  */
  43. static   char   PC1_C[] = {
  44.    57,49,41,33,25,17, 9,
  45.     1,58,50,42,34,26,18,
  46.    10, 2,59,51,43,35,27,
  47.    19,11, 3,60,52,44,36,
  48. };
  49.  
  50. static   char   PC1_D[] = {
  51.    63,55,47,39,31,23,15,
  52.     7,62,54,46,38,30,22,
  53.    14, 6,61,53,45,37,29,
  54.    21,13, 5,28,20,12, 4,
  55. };
  56.  
  57. /*
  58.  * Sequence of shifts used for the key schedule.
  59. */
  60. static   char   shifts[] = {
  61.    1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1,
  62. };
  63.  
  64. /*
  65.  * Permuted-choice 2, to pick out the bits from
  66.  * the CD array that generate the key schedule.
  67.  */
  68. static   char   PC2_C[] = {
  69.    14,17,11,24, 1, 5,
  70.     3,28,15, 6,21,10,
  71.    23,19,12, 4,26, 8,
  72.    16, 7,27,20,13, 2,
  73. };
  74.  
  75. static   char   PC2_D[] = {
  76.    41,52,31,37,47,55,
  77.    30,40,51,45,33,48,
  78.    44,49,39,56,34,53,
  79.    46,42,50,36,29,32,
  80. };
  81.  
  82. /*
  83.  * The C and D arrays used to calculate the key schedule.
  84.  */
  85.  
  86. static   char   C[28];
  87. static   char   D[28];
  88. /*
  89.  * The key schedule.
  90.  * Generated from the key.
  91.  */
  92. static   char   KS[16][48];
  93.  
  94. /*
  95.  * Set up the key schedule from the key.
  96.  */
  97.  
  98. setkey(key)
  99. char *key;
  100. {
  101.    register i, j, k;
  102.    int t;
  103.  
  104.    /*
  105.     * First, generate C and D by permuting
  106.     * the key.  The low order bit of each
  107.     * 8-bit char is not used, so C and D are only 28
  108.     * bits apiece.
  109.     */
  110.    for (i=0; i<28; i++) {
  111.       C[i] = key[PC1_C[i]-1];
  112.       D[i] = key[PC1_D[i]-1];
  113.    }
  114.    /*
  115.     * To generate Ki, rotate C and D according
  116.     * to schedule and pick up a permutation
  117.     * using PC2.
  118.     */
  119.    for (i=0; i<16; i++) {
  120.       /*
  121.        * rotate.
  122.        */
  123.       for (k=0; k<shifts[i]; k++) {
  124.          t = C[0];
  125.          for (j=0; j<28-1; j++)
  126.             C[j] = C[j+1];
  127.          C[27] = t;
  128.          t = D[0];
  129.          for (j=0; j<28-1; j++)
  130.             D[j] = D[j+1];
  131.          D[27] = t;
  132.       }
  133.       /*
  134.        * get Ki. Note C and D are concatenated.
  135.        */
  136.       for (j=0; j<24; j++) {
  137.          KS[i][j] = C[PC2_C[j]-1];
  138.          KS[i][j+24] = D[PC2_D[j]-28-1];
  139.       }
  140.    }
  141. }
  142.  
  143. /*
  144.  * The E bit-selection table.
  145.  */
  146. static   char   E[48];
  147. static   char   e[] = {
  148.    32, 1, 2, 3, 4, 5,
  149.     4, 5, 6, 7, 8, 9,
  150.     8, 9,10,11,12,13,
  151.    12,13,14,15,16,17,
  152.    16,17,18,19,20,21,
  153.    20,21,22,23,24,25,
  154.    24,25,26,27,28,29,
  155.    28,29,30,31,32, 1,
  156. };
  157.  
  158. /*
  159.  * The 8 selection functions.
  160.  * For some reason, they give a 0-origin
  161.  * index, unlike everything else.
  162.  */
  163. static   char   S[8][64] = {
  164.    14, 4,13, 1, 2,15,11, 8, 3,10, 6,12, 5, 9, 0, 7,
  165.     0,15, 7, 4,14, 2,13, 1,10, 6,12,11, 9, 5, 3, 8,
  166.     4, 1,14, 8,13, 6, 2,11,15,12, 9, 7, 3,10, 5, 0,
  167.    15,12, 8, 2, 4, 9, 1, 7, 5,11, 3,14,10, 0, 6,13,
  168.  
  169.    15, 1, 8,14, 6,11, 3, 4, 9, 7, 2,13,12, 0, 5,10,
  170.     3,13, 4, 7,15, 2, 8,14,12, 0, 1,10, 6, 9,11, 5,
  171.     0,14, 7,11,10, 4,13, 1, 5, 8,12, 6, 9, 3, 2,15,
  172.    13, 8,10, 1, 3,15, 4, 2,11, 6, 7,12, 0, 5,14, 9,
  173.  
  174.    10, 0, 9,14, 6, 3,15, 5, 1,13,12, 7,11, 4, 2, 8,
  175.    13, 7, 0, 9, 3, 4, 6,10, 2, 8, 5,14,12,11,15, 1,
  176.    13, 6, 4, 9, 8,15, 3, 0,11, 1, 2,12, 5,10,14, 7,
  177.     1,10,13, 0, 6, 9, 8, 7, 4,15,14, 3,11, 5, 2,12,
  178.  
  179.     7,13,14, 3, 0, 6, 9,10, 1, 2, 8, 5,11,12, 4,15,
  180.    13, 8,11, 5, 6,15, 0, 3, 4, 7, 2,12, 1,10,14, 9,
  181.    10, 6, 9, 0,12,11, 7,13,15, 1, 3,14, 5, 2, 8, 4,
  182.     3,15, 0, 6,10, 1,13, 8, 9, 4, 5,11,12, 7, 2,14,
  183.  
  184.     2,12, 4, 1, 7,10,11, 6, 8, 5, 3,15,13, 0,14, 9,
  185.    14,11, 2,12, 4, 7,13, 1, 5, 0,15,10, 3, 9, 8, 6,
  186.     4, 2, 1,11,10,13, 7, 8,15, 9,12, 5, 6, 3, 0,14,
  187.    11, 8,12, 7, 1,14, 2,13, 6,15, 0, 9,10, 4, 5, 3,
  188.  
  189.    12, 1,10,15, 9, 2, 6, 8, 0,13, 3, 4,14, 7, 5,11,
  190.    10,15, 4, 2, 7,12, 9, 5, 6, 1,13,14, 0,11, 3, 8,
  191.     9,14,15, 5, 2, 8,12, 3, 7, 0, 4,10, 1,13,11, 6,
  192.     4, 3, 2,12, 9, 5,15,10,11,14, 1, 7, 6, 0, 8,13,
  193.  
  194.     4,11, 2,14,15, 0, 8,13, 3,12, 9, 7, 5,10, 6, 1,
  195.    13, 0,11, 7, 4, 9, 1,10,14, 3, 5,12, 2,15, 8, 6,
  196.     1, 4,11,13,12, 3, 7,14,10,15, 6, 8, 0, 5, 9, 2,
  197.     6,11,13, 8, 1, 4,10, 7, 9, 5, 0,15,14, 2, 3,12,
  198.  
  199.    13, 2, 8, 4, 6,15,11, 1,10, 9, 3,14, 5, 0,12, 7,
  200.     1,15,13, 8,10, 3, 7, 4,12, 5, 6,11, 0,14, 9, 2,
  201.     7,11, 4, 1, 9,12,14, 2, 0, 6,10,13,15, 3, 5, 8,
  202.     2, 1,14, 7, 4,10, 8,13,15,12, 9, 0, 3, 5, 6,11,
  203. };
  204.  
  205. /*
  206.  * P is a permutation on the selected combination
  207.  * of the current L and key.
  208.  */
  209. static   char   P[] = {
  210.    16, 7,20,21,
  211.    29,12,28,17,
  212.     1,15,23,26,
  213.     5,18,31,10,
  214.     2, 8,24,14,
  215.    32,27, 3, 9,
  216.    19,13,30, 6,
  217.    22,11, 4,25,
  218. };
  219.  
  220. /*
  221.  * The current block, divided into 2 halves.
  222.  */
  223. static   char   L[32], R[32];
  224. static   char   tempL[32];
  225. static   char   f[32];
  226.  
  227. /*
  228.  * The combination of the key and the input, before selection.
  229.  */
  230. static   char   preS[48];
  231.  
  232. /*
  233.  * The payoff: encrypt a block.
  234.  */
  235.  
  236. encrypt(block, edflag)
  237. char *block;
  238. {
  239.    int i, ii;
  240.    register t, j, k;
  241.  
  242.    /*
  243.     * First, permute the bits in the input
  244.     */
  245.    for (j=0; j<64; j++)
  246.       L[j] = block[IP[j]-1];
  247.    /*
  248.     * Perform an encryption operation 16 times.
  249.     */
  250.    for (ii=0; ii<16; ii++) {
  251.       /*
  252.        * Set direction
  253.        */
  254.       if (edflag)
  255.          i = 15-ii;
  256.       else
  257.          i = ii;
  258.       /*
  259.        * Save the R array,
  260.        * which will be the new L.
  261.        */
  262.       for (j=0; j<32; j++)
  263.          tempL[j] = R[j];
  264.       /*
  265.        * Expand R to 48 bits using the E selector;
  266.        * exclusive-or with the current key bits.
  267.        */
  268.       for (j=0; j<48; j++)
  269.          preS[j] = R[E[j]-1] ^ KS[i][j];
  270.       /*
  271.        * The pre-select bits are now considered
  272.        * in 8 groups of 6 bits each.
  273.        * The 8 selection functions map these
  274.        * 6-bit quantities into 4-bit quantities
  275.        * and the results permuted
  276.        * to make an f(R, K).
  277.        * The indexing into the selection functions
  278.        * is peculiar; it could be simplified by
  279.        * rewriting the tables.
  280.        */
  281.       for (j=0; j<8; j++) {
  282.          t = 6*j;
  283.          k = S[j][(preS[t+0]<<5)+
  284.             (preS[t+1]<<3)+
  285.             (preS[t+2]<<2)+
  286.             (preS[t+3]<<1)+
  287.             (preS[t+4]<<0)+
  288.             (preS[t+5]<<4)];
  289.          t = 4*j;
  290.          f[t+0] = (k>>3)&01;
  291.          f[t+1] = (k>>2)&01;
  292.          f[t+2] = (k>>1)&01;
  293.          f[t+3] = (k>>0)&01;
  294.       }
  295.       /*
  296.        * The new R is L ^ f(R, K).
  297.        * The f here has to be permuted first, though.
  298.        */
  299.       for (j=0; j<32; j++)
  300.          R[j] = L[j] ^ f[P[j]-1];
  301.       /*
  302.        * Finally, the new L (the original R)
  303.        * is copied back.
  304.        */
  305.       for (j=0; j<32; j++)
  306.          L[j] = tempL[j];
  307.    }
  308.    /*
  309.     * The output L and R are reversed.
  310.     */
  311.    for (j=0; j<32; j++) {
  312.       t = L[j];
  313.       L[j] = R[j];
  314.       R[j] = t;
  315.    }
  316.    /*
  317.     * The final output
  318.     * gets the inverse permutation of the very original.
  319.     */
  320.    for (j=0; j<64; j++)
  321.       block[j] = L[FP[j]-1];
  322. }
  323.  
  324. char *
  325. crypt(pw,salt)
  326. char *pw;
  327. char *salt;
  328. {
  329.    register i, j, c;
  330.    int temp;
  331.    static char block[66], iobuf[16];
  332.    for(i=0; i<66; i++)
  333.       block[i] = 0;
  334.    for(i=0; (c= *pw) && i<64; pw++){
  335.       for(j=0; j<7; j++, i++)
  336.          block[i] = (c>>(6-j)) & 01;
  337.       i++;
  338.    }
  339.    
  340.    setkey(block);
  341.    
  342.    for(i=0; i<66; i++)
  343.       block[i] = 0;
  344.  
  345.    for(i=0;i<48;i++)
  346.       E[i] = e[i];
  347.  
  348.    for(i=0;i<2;i++){
  349.       c = *salt++;
  350.       iobuf[i] = c;
  351.       if(c>'Z') c -= 6;
  352.       if(c>'9') c -= 7;
  353.       c -= '.';
  354.       for(j=0;j<6;j++){
  355.          if((c>>j) & 01){
  356.             temp = E[6*i+j];
  357.             E[6*i+j] = E[6*i+j+24];
  358.             E[6*i+j+24] = temp;
  359.             }
  360.          }
  361.       }
  362.    
  363.    for(i=0; i<25; i++)
  364.       encrypt(block,0);
  365.    
  366.    for(i=0; i<11; i++){
  367.       c = 0;
  368.       for(j=0; j<6; j++){
  369.          c <<= 1;
  370.          c |= block[6*i+j];
  371.          }
  372.       c += '.';
  373.       if(c>'9') c += 7;
  374.       if(c>'Z') c += 6;
  375.       iobuf[i+2] = c;
  376.    }
  377.    iobuf[i+2] = 0;
  378.    if(iobuf[1]==0)
  379.       iobuf[1] = iobuf[0];
  380.    return(iobuf);
  381. }
  382.